TianyuCodings writes about JevHarness, a system where an LLM authors a task-specific harness for Jev (a lightweight judgment model from TypeSafe). The harness converts task observations into features, constructs Jev questions and criteria, and combines structured answers into actions. Once the harness is frozen, execution runs only the harness code and Jev calls without the authoring LLM on every decision. An optional GEPA evolution loop refines the harness using rewards and complete execution traces.
- Pokemon eval: 5 reflection rounds improved win rate from 25% (3/12) to 75% (9/12); the round-3 candidate was selected as best
- Selected harness median full decision: 568 ms (P95 657 ms); individual Jev request median: 269 ms (P95 348 ms)
- Installable as a Claude Code plugin or Codex skill; the skill guides the agent to clarify task inputs, legal actions, and success criteria before building
- Requires Python 3.11+; functional Python nodes need a macOS native sandbox and fail closed if unavailable
- The archived website and recorded-call inspection require no model credentials
- Pokemon eval: 5 reflection rounds improved win rate from 25% (3/12) to 75% (9/12); the round-3 candidate was selected as best
- Selected harness median full decision: 568 ms (P95 657 ms); individual Jev request median: 269 ms (P95 348 ms)
- Installable as a Claude Code plugin or Codex skill; the skill guides the agent to clarify task inputs, legal actions, and success criteria before building
- Requires Python 3.11+; functional Python nodes need a macOS native sandbox and fail closed if unavailable
- The archived website and recorded-call inspection require no model credentials
Abhijith N Arjunan writes that Qwen Code is an open-source AI coding agent that effectively replaces Claude Code, offering better flexibility and being completely free to use. The tool allows users to connect with almost every AI provider, including local AI tools, and can be configured with various models like DeepSeek or OpenRouter. Setup is straightforward, and the tool supports features like subagents, hooks, skills, and sandbox environments. While Qwen Code may not yet match the stability of Claude Code in some areas, it provides greater freedom and is continuously updated.
Benjamin Marie writes that the effectiveness of an LLM in long-horizon agentic coding tasks depends heavily on the harness used to drive it rather than just the model itself. Through testing Qwen3.8 27B across three different interfaces—Mini-SWE Agent, Claude Code, and Pi—the author found that while specific configurations like "benchmaxxed" Pi can solve the highest number of tasks, other setups like Claude Code achieve better functional coverage (F2P). The study highlights how critical engineering choices, such as preserving reasoning traces or managing output token limits, are essential for successful agentic performance.
- The evaluation used DeepSWE 1.1, a benchmark comprising 113 long-horizon tasks from 91 open-source repositories.
- Performance varies significantly based on whether reasoning traces are preserved between turns and how context budgets are managed.
- Pi at medium effort was found to offer the best balance of efficiency and accuracy.
- Results were influenced by factors like session recovery, patch reliability, and output-token settings. author »
- The evaluation used DeepSWE 1.1, a benchmark comprising 113 long-horizon tasks from 91 open-source repositories.
- Performance varies significantly based on whether reasoning traces are preserved between turns and how context budgets are managed.
- Pi at medium effort was found to offer the best balance of efficiency and accuracy.
- Results were influenced by factors like session recovery, patch reliability, and output-token settings. author »
Supreeth Koundinya writes that Spotify has successfully reduced token consumption for its internal coding agent, Claude Code, by approximately 90% through a model routing approach. By using their "Portal" developer platform and "AiKA Modes," the company directs repetitive or I/O-intensive tasks—such as file reading and basic code generation—to cheaper models like Google's Gemini 2.5 Flash, reserving Anthropic's frontier Claude models for complex reasoning and debugging.
- Routing is facilitated by a plugin called Shunt using PreToolUse hooks to intercept large file reads.
- The system uses ephemeral runtimes via AiKA modes so developers don't have to manage infrastructure or API keys manually.
- To prevent context bloat, Claude Code does not directly consume the output of generated code written by worker models to disk.
- Current limitations include a 30-second invocation limit and potential loss of line-level detail during delegated analysis.
- Routing is facilitated by a plugin called Shunt using PreToolUse hooks to intercept large file reads.
- The system uses ephemeral runtimes via AiKA modes so developers don't have to manage infrastructure or API keys manually.
- To prevent context bloat, Claude Code does not directly consume the output of generated code written by worker models to disk.
- Current limitations include a 30-second invocation limit and potential loss of line-level detail during delegated analysis.
Anurag Singh writes that using Claude Code's auto mode can be frustrating when the tool constantly requests permission for terminal commands, which often breaks its autonomy. To solve this while maintaining security, he suggests running Claude Code inside a virtual machine (VM) with Ubuntu; this provides a safe sandbox where "auto mode" can run freely without risking personal files or credentials on the host computer.
- The author uses VirtualBox to create the VM environment.
- Running in auto mode within a VM allows for background file editing, testing, and error handling without constant human interruption.
- Even with built-in sandboxing in Claude Code, Singh argues that a VM is safer because it provides full operating system separation.
- After tasks are complete, the user should review Git diffs and run tests before moving code from the VM to the main project.
- The author uses VirtualBox to create the VM environment.
- Running in auto mode within a VM allows for background file editing, testing, and error handling without constant human interruption.
- Even with built-in sandboxing in Claude Code, Singh argues that a VM is safer because it provides full operating system separation.
- After tasks are complete, the user should review Git diffs and run tests before moving code from the VM to the main project.
Anurag Singh writes that providing Claude Code with read-only access to a SaaS application's server logs allowed the coding agent to identify and propose fixes for real performance issues. By observing error patterns, traces, and metrics directly within the environment rather than relying on manual bug reports, the agent was able to autonomously trace bugs back to specific lines of code across various files.
- The experiment highlights a shift toward AI agents joining the "on-call" workflow by inspecting live operational telemetry.
- To mitigate security risks, it is recommended using Model Context Protocol (MCP) servers to restrict an agent's tools to read-only actions.
- Major observability companies like Sentry and Datadog are already implementing similar features to automate root cause analysis and pull request generation.
- The experiment highlights a shift toward AI agents joining the "on-call" workflow by inspecting live operational telemetry.
- To mitigate security risks, it is recommended using Model Context Protocol (MCP) servers to restrict an agent's tools to read-only actions.
- Major observability companies like Sentry and Datadog are already implementing similar features to automate root cause analysis and pull request generation.
Anurag Singh writes about combining Claude Code's Auto mode with deny rules and ask rules to eliminate the need to manually approve every command. The setup lets Claude Code work uninterrupted in the background while hard-blocking destructive commands like force-pushes and rm -rf, and optionally prompting on risky-but-acceptable actions like git push.
- Deny rules are enforced by Claude Code itself rather than being instructions to the model, so they hold even in bypassPermissions mode
- A deny list can never be exhaustive; Claude could accomplish the same destructive action through a different tool (e.g., Python instead of rm)
- The built-in sandbox is a stronger safety net than any deny list, though it becomes tedious for projects depending on local databases, Docker, or private registries
- Permission rules are evaluated in fixed priority order: deny first, then ask, then allow
- Deny rules are enforced by Claude Code itself rather than being instructions to the model, so they hold even in bypassPermissions mode
- A deny list can never be exhaustive; Claude could accomplish the same destructive action through a different tool (e.g., Python instead of rm)
- The built-in sandbox is a stronger safety net than any deny list, though it becomes tedious for projects depending on local databases, Docker, or private registries
- Permission rules are evaluated in fixed priority order: deny first, then ask, then allow
Anurag Singh writes about using a Stop hook in Claude Code to force the agent to review its work against a checklist of previously made mistakes before finishing, solving the problem of the model repeating the same errors across sessions despite CLAUDE.md instructions and prompt-level guidance.
- The hook is a Bash script that uses jq to read a mistakes.md file and inject a "block" decision, sending Claude back for a second review pass.
- The script checks the stop_hook_active flag to avoid an infinite review loop.
- A TaskCompleted event hook is a more token-efficient alternative if you only want review on task completion rather than every response.
- Hooks execute deterministically on trigger events, unlike textual instructions in CLAUDE.md which Claude may treat as optional.
- The hook is a Bash script that uses jq to read a mistakes.md file and inject a "block" decision, sending Claude back for a second review pass.
- The script checks the stop_hook_active flag to avoid an infinite review loop.
- A TaskCompleted event hook is a more token-efficient alternative if you only want review on task completion rather than every response.
- Hooks execute deterministically on trigger events, unlike textual instructions in CLAUDE.md which Claude may treat as optional.
Michael Nuñez writes about Slack Code, a new product that embeds AI coding agents'', including Anthropic's Claude Code, Cognition's Devin, GitHub Copilot, and Vercel's agent'', into dedicated Slack channels where entire teams can watch, steer, review, and ship software together. The pitch reframes AI coding from a solitary terminal exercise into a "multiplayer" newsroom workflow: tagging an agent spawns a project-specific channel with live code diffs, previews, and a running plan, then archives into a searchable audit trail. Slack argues that with generation no longer the scarce step, the bottleneck has shifted to human judgment, taste, and craft work any team member can contribute to in a shared channel.
- Cognition reported internal merged PRs up 10x while headcount rose only 40%, with engineers simultaneously managing "dozens of agents."
- Security model: agents inherit the invoking user's ACLs with no bot-level or god permissions; Devin sandboxes run with "minimum viable access" and an optional
- Cognition reported internal merged PRs up 10x while headcount rose only 40%, with engineers simultaneously managing "dozens of agents."
- Security model: agents inherit the invoking user's ACLs with no bot-level or god permissions; Devin sandboxes run with "minimum viable access" and an optional
This XDA Developers article by Anurag Singh explains how a **CLAUDE.md** file at the root of a repository solves the problem of Claude Code repeatedly asking the same setup questions in every new session.
**The problem:** Each Claude Code session starts with a fresh context window, so it has no memory of previous conversations. It must re-inspect the repo and re-infer project conventions (package manager, test commands, directory rules, etc.), wasting time and tokens—and sometimes reaching different conclusions.
**The solution:** A `CLAUDE.md` file that Claude Code automatically loads at the start of every session. It acts as a persistent onboarding document containing:
- **Commands** (e.g., "Use pnpm," "Run `pnpm test` before completing a task")
- **Project structure rules** (e.g., "Reusable components go in `src/components/`," "Do not edit `src/generated/`")
- **Working rules** (e.g., "Reuse existing components," "Ask before installing a dependency," "Make the smallest change required")
**How to create it:** Either write it manually or run `/init` inside Claude Code, which auto-generates a starting file from the repo. If one already exists, `/init` suggests changes rather than overwriting.
**Best practices:**
- Keep it under ~200 lines (treat as a ceiling, not a target).
- Be specific—avoid vague instructions like "write clean code."
- Don't duplicate content Claude can discover by reading the repo (don't make it another README).
- Watch for conflicting rules across multiple instruction files.
**File hierarchy:**
| File | Scope |
|---|---|
| `~/.claude/CLAUDE.md` | Global, all projects |
| `CLAUDE.md` (repo root) | Project-level, commit to version control |
| `CLAUDE.local.md` | Personal, add to `.gitignore` |
The author notes that Claude Code's built-in "auto memory" is unreliable for critical rules because Claude decides what to save there; a hand-written CLAUDE.md is exact and shareable.
**The problem:** Each Claude Code session starts with a fresh context window, so it has no memory of previous conversations. It must re-inspect the repo and re-infer project conventions (package manager, test commands, directory rules, etc.), wasting time and tokens—and sometimes reaching different conclusions.
**The solution:** A `CLAUDE.md` file that Claude Code automatically loads at the start of every session. It acts as a persistent onboarding document containing:
- **Commands** (e.g., "Use pnpm," "Run `pnpm test` before completing a task")
- **Project structure rules** (e.g., "Reusable components go in `src/components/`," "Do not edit `src/generated/`")
- **Working rules** (e.g., "Reuse existing components," "Ask before installing a dependency," "Make the smallest change required")
**How to create it:** Either write it manually or run `/init` inside Claude Code, which auto-generates a starting file from the repo. If one already exists, `/init` suggests changes rather than overwriting.
**Best practices:**
- Keep it under ~200 lines (treat as a ceiling, not a target).
- Be specific—avoid vague instructions like "write clean code."
- Don't duplicate content Claude can discover by reading the repo (don't make it another README).
- Watch for conflicting rules across multiple instruction files.
**File hierarchy:**
| File | Scope |
|---|---|
| `~/.claude/CLAUDE.md` | Global, all projects |
| `CLAUDE.md` (repo root) | Project-level, commit to version control |
| `CLAUDE.local.md` | Personal, add to `.gitignore` |
The author notes that Claude Code's built-in "auto memory" is unreliable for critical rules because Claude decides what to save there; a hand-written CLAUDE.md is exact and shareable.
